\chapter{Introduction}

Despite the competition of modern computer games, turn-based board games remain popular around the world.
Since new board games are being invented every year, we are interested in rapid prototyping of generic board games on computers.

To tackle this problem we developed a generic board game language.
The scope of this project will not only include strategy games, but also other types of games such as casual board games\footnote{Casual board games are games that are easy to learn and have simple rules.}.
 
This report concerns language design, as well as compiler and interpreter construction. A compiler translates program code to another programming language or into machine code, whereas an interpreter executes the source code immediately, meaning that it is not compiled into a lower level language, but is directly executed. More information about this topic can be found in section \ref{section:compilermodel}.

For a generic board game language with focus on rapid prototyping, it is important to find a balance between simplicity and general applicability. The developer should be able to make a wide variety of board games with as little effort as possible.
In order to describe a board game, the developer has to be able to specify the basic elements in the board game like the number of players, the size of the board, the order of the players' turns, as well as the rules of play. See section \ref{chapter:ProblemDomain} for more information.

The target audience (further described in section \ref{sec:application_domain}) of the language are board game developers with little to no knowledge of programming while the target audience of the report are university students with knowledge within the topic of compiler and interpreter construction.
The product of this project aims to be useful for board game development companies.

In chapter \ref{chapter:implementation} we describe what we implemented, and in chapter \ref{chapter::FutureWork} we are going to describe what our ideal image of the language looks like.

\section{Problem Statement}
In this project we want to make a generic language for simple board game construction, allowing users to quickly prototype board game ideas. The language is a high level language taking people who are inexperienced in programming concepts into consideration. Predefined variables defining properties of common game elements serve to make programming easier and faster. We want to construct a program which can interpret our language and execute it.

The reason why we want to make a computerized board game is that we want the developers of board games to be able to easily test out new board game ideas. For this project we would like to make a \textit{compiler or interpreter} that enables a board game developer to quickly implement and test his ideas. In addition to that he should be able to import his own boards and pieces.

\section{Group Goals}
Since the topic of the project is \textit{Programming Languages and Compilers}, the main goal of the group is to gain an understanding of the concepts of programming languages and
compilers. In order to do so, we will construct a programming language for prototyping board games, as well as an interpreter being able to read and execute games written in a programming language. In addition to this main goal we wish to improve our project management and teamwork capabilities.

To sum up, the goals are as follows.
\begin{enumerate}
\item Learn about programming languages and make our own programming language.
	\begin{enumerate}
		\item Construct a grammar and syntax for our language.
		\item Our programming language should be easy to read, write and learn.
	\end{enumerate}
\item Learn about compilers and interpreters.
\item Make a working interpreter or compiler.
\end{enumerate}

\section{Summary of the Project}
In chapter \ref{chapter:Analysingexistingboardgames} we look at a few board games, their rules and try to establish what components they consist of.
Then in chapter \ref{chapter:ProblemDomain}, we give a more general description of board games which we obtainted through the chapter \ref{chapter:Analysingexistingboardgames}.
In chapter \ref{chapter::Design} we discuss which criterion is important for our language. The chapter also includes an overview of the different paradigms our language uses, and at the end of the chapter we look at the concrete design.
In chapter \ref{chapter:implementation} we focus on what was actually implemented while introducing some essientiel knowlegde about compiler and interpreter construction.
In chapter \ref{chapter::FutureWork} we are going to describe what a finished version of the language would be like.




